#include <stdint.h>
#include <math.h> // 用于数学计算
#include <stdio.h>
#include <string.h>
#include "render.h"
#include "widget/widget.h"
#include "selector.h"
#include "list.h"
#include "font/font.h"
#include "memory.h"

render_t render;

widget_render_func widget_render_func_register_table[widget_type_max]={0};

/// @brief 设置渲染对象，即可实现分层渲染，图层叠加
void render_set_render_widget(widget_t *obj);
void reder_draw_widget(widget_t *widget);
void render_draw_pixel(int x, int y);

/// @brief 绘制线段
/// @param x1  
/// @param y1 
/// @param x2 
/// @param y2 
void render_draw_line(int x1, int y1, int x2, int y2)
{
    int dx = abs(x2 - x1);
    int dy = abs(y2 - y1);
    int sx = (x1 < x2) ? 1 : -1;
    int sy = (y1 < y2) ? 1 : -1;
    int err = dx - dy;

    while (1)
    {
        // 计算在GUI RAM中的字节索引和位偏移
        int byte_index = y1 * (render.w / 8) + x1 / 8;
        int bit_offset = 7 - (x1 % 8);

        // 设置对应的位为1（白色）
        render.gui_ram[byte_index] |= (1 << bit_offset);

        if (x1 == x2 && y1 == y2)
            break;

        int e2 = 2 * err;
        if (e2 > -dy)
        {
            err -= dy;
            x1 += sx;
        }

        if (e2 < dx)
        {
            err += dx;
            y1 += sy;
        }
    }
}

/// @brief 绘制矩形

void render_draw_rect(int x, int y, int w, int h)
{
    render_draw_line(x, y, x + w, y);
    render_draw_line(x, y, x, y + h);
    render_draw_line(x, y + h, x + w, y + h);
    render_draw_line(x + w, y, x + w, y + h);
}

/// @brief 绘制图片
void render_draw_img(int x, int y, int w, int h, const uint8_t *img)
{
    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            // 计算在GUI RAM中的字节索引和位偏移
            int byte_index = (y + i) * (render.w / 8) + (x + j) / 8;
            int bit_offset = 7 - ((x + j) % 8);

            // 设置对应的位为1（白色）
            render.gui_ram[byte_index] |= (1 << bit_offset);
        }
    }
}

/// @brief 绘制圆形
void render_draw_circle(int x, int y, int r)
{
    int a = 0;
    int b = r;
    int d = 3 - 2 * r;

    while (a <= b)
    {
        // 计算在GUI RAM中的字节索引和位偏移
        int byte_index_top = (y + a) * (render.w / 8) + (x + b) / 8;
        int bit_offset_top = 7 - ((x + b) % 8);
        int byte_index_bottom = (y - a) * (render.w / 8) + (x + b) / 8;
        int bit_offset_bottom = 7 - ((x + b) % 8);
        int byte_index_left = (y + b) * (render.w / 8) + (x + a) / 8;
        int bit_offset_left = 7 - ((x + a) % 8);
        int byte_index_right = (y + b) * (render.w / 8) + (x - a) / 8;
        int bit_offset_right = 7 - ((x - a) % 8);

        // 设置对应的位为1（白色）
        render.gui_ram[byte_index_top] |= (1 << bit_offset_top);
        render.gui_ram[byte_index_bottom] |= (1 << bit_offset_bottom);
        render.gui_ram[byte_index_left] |= (1 << bit_offset_left);
        render.gui_ram[byte_index_right] |= (1 << bit_offset_right);

        a++;
        if (d < 0)
        {
            d = d + 4 * a + 6;
        }
        else
        {
            d = d + 4 * (a - b) + 10;
            b--;
        }
    }
}

// 函数：绘制圆角矩形
// 参数：
//   x: 矩形左上角的x坐标
//   y: 矩形左上角的y坐标
//   w: 矩形的宽度
//   h: 矩形的高度
//   r: 圆角的半径
void render_draw_rounded_rect(int x, int y, int w, int h, int r)
{
    // 绘制矩形的四条边
    render_draw_line(x + r, y, x + w - r, y); // 上边框
    render_draw_line(x + r, y + h, x + w - r, y + h); // 下边框
    render_draw_line(x, y + r, x, y + h - r); // 左边框
    render_draw_line(x + w, y + r, x + w, y + h - r); // 右边框

    // 绘制四个角
    for (int i = 0; i <= r; i++)
    {
        for (int j = 0; j <= r; j++)
        {
            if (sqrt(i * i + j * j) <= r)
            {
                render_draw_pixel(x + i, y + j); // 左上角
                render_draw_pixel(x + w - i, y + j); // 右上角
                render_draw_pixel(x + i, y + h - j); // 左下角
                render_draw_pixel(x + w - i, y + h - j); // 右下角
            }
        }
    }
}

// 函数：绘制单个像素
// 参数：
//   x: 像素的x坐标
//   y: 像素的y坐标
void render_draw_pixel(int x, int y)
{
    // 计算在GRAM中的字节索引和位偏移
    int byte_index = y * (render.w / 8) + x / 8;
    int bit_offset = 7 - (x % 8);

    // 设置对应的位为1（白色）
    render.gui_ram[byte_index] |= (1 << bit_offset);
}

/// @brief 绘制文本
/// @param x 
/// @param y 
/// @param text 
void render_draw_text(int x, int y, const char *text)
{
    font_data_str_data_t str_data = font_get_fontdata(text);
    for (int i = 0; i < str_data.font_cnt; i++)
    {
        for (int j = 0; j < str_data.font_desc[i].font_height; j++)
        {
            for (int k = 0; k < str_data.font_desc[i].font_width; k++)
            {
                if (str_data.font_desc[i].font_data[j * str_data.font_desc[i].font_width + k])
                {
                    render.gui_ram[(y + j) * render.w / 8 + (x + k) / 8] |= (1 << (7 - (x + k) % 8));
                }
            }
        }
        x += str_data.font_desc[i].font_width;
    }
}


void reder_draw_widget(widget_t* sel_widget)
{
    widget_render_func func = widget_render_func_register_table[sel_widget->widget_type];
    if(func)
    {
        func(sel_widget);
    }
}


void render_main_loop(void)
{
    // 获取当前选中的对象进行渲染
    widget_t *sel_widget = selector_get_sel_node();
    widget_t *render_widget = render.render_obj;

    // 渲染
    if (sel_widget != render_widget)
    {
        render_set_render_widget(sel_widget);
        reder_draw_widget(sel_widget);
    }
}

render_gram_desc_t render_get_gram(void)
{
    render_gram_desc_t desc;
    desc.w = render.w;
    desc.h = render.h;
    desc.gui_ram = render.gui_ram;
    return desc;
}



/// @brief 初始化渲染器
void render_init(may_screen_t *screen)
{
    // 设置容器为screen
    memset(&render, 0, sizeof(render_t));
    render_set_render_widget(&screen->obj);
}




void render_widget_func_register(widget_type_e type, widget_render_func func)
{
    widget_render_func_register_table[type] = func;
}



/// @brief 设置需要渲染的对象，并设置渲染区域，即可实现分层渲染，图层叠加
/// @param obj 需要渲染的对象
void render_set_render_widget(widget_t *obj)
{
    widget_t *widget = (widget_t *)obj;

    {
        render.w = widget->w;
        render.h = widget->h;
        render.render_obj = widget;

        if (render.ram_w != widget->w || render.ram_h != widget->h)
        {
            render.ram_w = widget->w;
            render.ram_h = widget->h;
            memory_free(render.gui_ram);
            render.gui_ram = (uint8_t *)memory_alloc(widget->w * widget->h / 8);
        }
    }
}


void render_widget(widget_t *widget)
{
    widget_type_e type = widget->widget_type;
    widget_render_func func = widget_render_func_register_table[type];
    
    if(func)
    {
        //执行渲染函数
        func(widget);
    }
}